package org.alwayssuper.protocol.commons.transform.realtimev2025;

import org.alwayssuper.protostar.annotation.Field;
import lombok.Data;
import lombok.ToString;
import lombok.experimental.Accessors;

import java.util.List;

/**
 * 2025版燃料电池电堆数据格式 (0x30)
 * 参考GB/T 32960.3-2025标准表18-19
 * @author alwaysSuper
 */
@ToString
@Data
@Accessors(chain = true)
public class FuelCellStackData {
    // 燃料电池电堆个数:1~253个燃料电池电堆个数(由fuelCellStackList的totalUnit获取)
    private int fuelCellStackCount;
    
    @Field(totalUnit = 1, desc = "燃料电池电堆信息表")
    private List<FuelCellStackInfo> fuelCellStackList;
    
    @ToString
    @Data
    @Accessors(chain = true)
    public static class FuelCellStackInfo {
        @Field(length = 1, desc = "燃料电池电堆序号:有效值范围1~253")
        private int stackSequence;
        
        @Field(length = 2, desc = "燃料电池电堆电压:有效值范围0~20000(表示0V~2000V),精度0.1V")
        private int stackVoltage;
        
        @Field(length = 2, desc = "燃料电池电堆电流:有效值范围0~20000(表示0A~2000A),精度0.1A")
        private int stackCurrent;
        
        @Field(length = 2, desc = "氢气入口压力:有效值范围0~5000(偏移100kPa,-100~400kPa),精度0.1kPa")
        private int hydrogenInletPressure;
        
        @Field(length = 2, desc = "空气入口压力:有效值范围0~5000(偏移100kPa,-100~400kPa),精度0.1kPa")
        private int airInletPressure;
        
        @Field(length = 1, desc = "空气入口温度:有效值范围0~250(偏移40℃,-40℃~+210℃),精度1℃")
        private int airInletTemperature;
        
        // 冷却水出水口温度探针总数:N个温度探针,有效值范围:0~65531(由coolantOutletTemperatures的totalUnit获取)
        private int coolantOutletTemperatureProbeCount;
        
        @Field(totalUnit = 2, desc = "冷却水出水口温度列表")
        private List<CoolantOutletTemperature> coolantOutletTemperatures;

        // 通过coolantOutletTemperatures列表长度返回coolantOutletTemperatureProbeCount
        public int getCoolantOutletTemperatureProbeCount() {
            return coolantOutletTemperatures == null ? 0 : coolantOutletTemperatures.size();
        }
        
        // ==================== 传输值与真实值转换方法 ====================
        
        /**
         * 获取燃料电池电堆电压 (V)
         * @return 电压，精度0.1V，异常返回-1，无效返回-2
         */
        public double getStackVoltage() {
            if (stackVoltage == 0xFFFE) return -1.0; // 异常
            if (stackVoltage == 0xFFFF) return -2.0; // 无效
            return stackVoltage * 0.1; // 传输值×0.1 = 值(V)
        }
        
        /**
         * 设置燃料电池电堆电压 (V)
         * @param voltage 电压值，范围0~2000V
         */
        public void setStackVoltage(double voltage) {
            if (voltage < 0 || voltage > 2000.0) {
                this.stackVoltage = 0xFFFF; // 无效值
            } else {
                this.stackVoltage = (int) Math.round(voltage * 10); // 值×10 = 传输值
            }
        }
        
        /**
         * 获取燃料电池电堆电流 (A)
         * @return 电流，精度0.1A，异常返回-1，无效返回-2
         */
        public double getStackCurrent() {
            if (stackCurrent == 0xFFFE) return -1.0; // 异常
            if (stackCurrent == 0xFFFF) return -2.0; // 无效
            return stackCurrent * 0.1; // 传输值×0.1 = 值(A)
        }
        
        /**
         * 设置燃料电池电堆电流 (A)
         * @param current 电流值，范围0~2000A
         */
        public void setStackCurrent(double current) {
            if (current < 0 || current > 2000.0) {
                this.stackCurrent = 0xFFFF; // 无效值
            } else {
                this.stackCurrent = (int) Math.round(current * 10); // 值×10 = 传输值
            }
        }
        
        /**
         * 获取氢气入口压力 (kPa)
         * @return 压力，精度0.1kPa，异常返回-999，无效返回-1000
         */
        public double getHydrogenInletPressure() {
            if (hydrogenInletPressure == 0xFFFE) return -999.0; // 异常
            if (hydrogenInletPressure == 0xFFFF) return -1000.0; // 无效
            return (hydrogenInletPressure - 1000) * 0.1; // (传输值-1000)×0.1 = 值(kPa)，支持负值
        }
        
        /**
         * 设置氢气入口压力 (kPa)
         * @param pressure 压力值，范围-100~400kPa
         */
        public void setHydrogenInletPressure(double pressure) {
            if (pressure < -100.0 || pressure > 400.0) {
                this.hydrogenInletPressure = 0xFFFF; // 无效值
            } else {
                this.hydrogenInletPressure = (int) Math.round(pressure * 10 + 1000); // (值×10)+1000 = 传输值
            }
        }
        
        /**
         * 获取空气入口压力 (kPa)
         * @return 压力，精度0.1kPa，异常返回-999，无效返回-1000
         */
        public double getAirInletPressure() {
            if (airInletPressure == 0xFFFE) return -999.0; // 异常
            if (airInletPressure == 0xFFFF) return -1000.0; // 无效
            return (airInletPressure - 1000) * 0.1; // (传输值-1000)×0.1 = 值(kPa)，支持负值
        }
        
        /**
         * 设置空气入口压力 (kPa)
         * @param pressure 压力值，范围-100~400kPa
         */
        public void setAirInletPressure(double pressure) {
            if (pressure < -100.0 || pressure > 400.0) {
                this.airInletPressure = 0xFFFF; // 无效值
            } else {
                this.airInletPressure = (int) Math.round(pressure * 10 + 1000); // (值×10)+1000 = 传输值
            }
        }
        
        /**
         * 获取空气入口温度 (℃)
         * @return 温度，精度1℃，异常返回-999，无效返回-1000
         */
        public int getAirInletTemperature() {
            if (airInletTemperature == 0xFE) return -999; // 异常
            if (airInletTemperature == 0xFF) return -1000; // 无效
            return airInletTemperature - 40; // (传输值-40) = 值(℃)，支持负值
        }
        
        /**
         * 设置空气入口温度 (℃)
         * @param temperature 温度值，范围-40℃~+210℃
         */
        public void setAirInletTemperature(int temperature) {
            if (temperature < -40 || temperature > 210) {
                this.airInletTemperature = 0xFF; // 无效值
            } else {
                this.airInletTemperature = temperature + 40; // (值+40) = 传输值
            }
        }
        
        /**
         * 检查燃料电池电堆电压是否有效
         * @return true: 有效, false: 异常或无效
         */
        public boolean isStackVoltageValid() {
            return stackVoltage != 0xFFFE && stackVoltage != 0xFFFF;
        }
        
        /**
         * 检查燃料电池电堆电流是否有效
         * @return true: 有效, false: 异常或无效
         */
        public boolean isStackCurrentValid() {
            return stackCurrent != 0xFFFE && stackCurrent != 0xFFFF;
        }
        
        /**
         * 检查氢气入口压力是否有效
         * @return true: 有效, false: 异常或无效
         */
        public boolean isHydrogenInletPressureValid() {
            return hydrogenInletPressure != 0xFFFE && hydrogenInletPressure != 0xFFFF;
        }
        
        /**
         * 检查空气入口压力是否有效
         * @return true: 有效, false: 异常或无效
         */
        public boolean isAirInletPressureValid() {
            return airInletPressure != 0xFFFE && airInletPressure != 0xFFFF;
        }
        
        /**
         * 检查空气入口温度是否有效
         * @return true: 有效, false: 异常或无效
         */
        public boolean isAirInletTemperatureValid() {
            return airInletTemperature != 0xFE && airInletTemperature != 0xFF;
        }
    }
    
    @Data
    @Accessors(chain = true)
    public static class CoolantOutletTemperature {
        @Field(length = 1, desc = "冷却水出水口温度:有效值范围0~250(偏移40℃,-40℃~+210℃),精度1℃")
        private int temperature;
        
        // ==================== 传输值与真实值转换方法 ====================
        
        /**
         * 获取冷却水出水口温度 (℃)
         * @return 温度，精度1℃，异常返回-999，无效返回-1000
         */
        public int getTemperature() {
            if (temperature == 0xFE) return -999; // 异常
            if (temperature == 0xFF) return -1000; // 无效
            return temperature - 40; // (传输值-40) = 值(℃)，支持负值
        }
        
        /**
         * 设置冷却水出水口温度 (℃)
         * @param temperature 温度值，范围-40℃~+210℃
         */
        public void setTemperature(int temperature) {
            if (temperature < -40 || temperature > 210) {
                this.temperature = 0xFF; // 无效值
            } else {
                this.temperature = temperature + 40; // (值+40) = 传输值
            }
        }
        
        /**
         * 检查冷却水出水口温度是否有效
         * @return true: 有效, false: 异常或无效
         */
        public boolean isTemperatureValid() {
            return temperature != 0xFE && temperature != 0xFF;
        }
    }
    
    // 通过fuelCellStackList列表长度返回fuelCellStackCount
    public int getFuelCellStackCount() {
        return fuelCellStackList == null ? 0 : fuelCellStackList.size();
    }
}